// pages/orderList/orderList.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    // 当前选中的选项卡
    currentTab: 'all',
    // 选项卡对应的文字
    tabText: '',
    // 所有订单
    allOrders: [],
    // 当前选项卡过滤后的订单
    filteredOrders: [],
    // 状态文本映射
    statusText: {
      'pending': '待付款',
      'paid': '已付款',
      'completed': '已完成',
      'cancelled': '已取消'
    },
    // 是否有更多订单
    hasMoreOrders: false,
    // 是否正在加载
    isLoading: false,
    // 当前页码
    currentPage: 1,
    // 每页订单数
    pageSize: 10
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 如果有传入选项卡参数，则切换到对应选项卡
    if (options.tab) {
      this.setData({
        currentTab: options.tab
      });
    }

    // 初始化选项卡文字
    this.setTabText();

    // 加载订单数据
    this.loadOrders();
  },

  /**
   * 设置选项卡对应的文字
   */
  setTabText() {
    let tabText = '';
    switch (this.data.currentTab) {
      case 'pending':
        tabText = '待付款';
        break;
      case 'paid':
        tabText = '已付款';
        break;
      case 'completed':
        tabText = '已完成';
        break;
      default:
        tabText = '';
    }

    this.setData({
      tabText
    });
  },

  /**
   * 加载订单数据
   */
  loadOrders() {
    this.setData({
      isLoading: true
    });

    console.log('正在从云数据库加载订单数据');

    // 调用云函数获取订单列表
    wx.cloud.callFunction({
      name: 'getOrders',
      data: {
        status: this.data.currentTab === 'all' ? null : this.data.currentTab
      }
    })
      .then(res => {
        console.log('获取到的订单数据:', res.result);

        this.setData({
          allOrders: res.result || [],
          isLoading: false
        });

        // 根据选项卡过滤订单
        this.filterOrders();
      })
      .catch(err => {
        console.error('获取订单失败:', err);
        this.setData({
          isLoading: false
        });

        wx.showToast({
          title: '加载订单失败',
          icon: 'none'
        });
      });
  },

  /**
   * 根据选项卡过滤订单
   */
  filterOrders() {
    const { allOrders, currentTab } = this.data;
    let filteredOrders = [];

    if (currentTab === 'all') {
      // 全部订单
      filteredOrders = allOrders;
    } else {
      // 根据状态筛选
      filteredOrders = allOrders.filter(order => order.status === currentTab);
    }

    console.log('过滤结果:', currentTab, '订单数量:', filteredOrders.length);
    console.log('订单状态分布:', this.getOrderStatusCounts(allOrders));

    this.setData({
      filteredOrders,
      hasMoreOrders: filteredOrders.length > this.data.pageSize
    });
  },

  /**
   * 统计各状态订单数量（用于调试）
   */
  getOrderStatusCounts(orders) {
    const counts = {
      total: orders.length,
      pending: 0,
      paid: 0,
      completed: 0,
      cancelled: 0,
      other: 0
    };

    orders.forEach(order => {
      if (order.status === 'pending') counts.pending++;
      else if (order.status === 'paid') counts.paid++;
      else if (order.status === 'completed') counts.completed++;
      else if (order.status === 'cancelled') counts.cancelled++;
      else counts.other++;
    });

    return counts;
  },

  /**
   * 切换选项卡
   */
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;

    if (tab === this.data.currentTab) {
      return;
    }

    this.setData({
      currentTab: tab,
      currentPage: 1
    });

    this.setTabText();
    this.filterOrders();
  },

  /**
   * 查看订单详情
   */
  viewOrderDetail(e) {
    const orderId = e.currentTarget.dataset.id;

    // 存储选中的订单ID到缓存
    wx.setStorageSync('currentOrderId', orderId);

    // 跳转到订单详情页（这里暂时用提示代替，实际项目中应跳转到订单详情页）
    wx.showModal({
      title: '提示',
      content: '将跳转到订单详情页，订单ID：' + orderId,
      showCancel: false
    });
  },

  /**
   * 支付订单
   */
  payOrder(e) {
    // 微信小程序事件对象不支持stopPropagation方法
    // 使用catchtap已经足够阻止冒泡

    const orderId = e.currentTarget.dataset.id;
    console.log('支付订单, orderId:', orderId);

    // 在数据中查找匹配的订单
    const orderIndex = this.data.filteredOrders.findIndex(order =>
      order.orderId === orderId || order._id === orderId
    );

    if (orderIndex === -1) {
      console.error('无效的订单ID');
      wx.showToast({
        title: '订单信息有误',
        icon: 'none'
      });
      return;
    }

    const foundOrder = this.data.filteredOrders[orderIndex];
    const validOrderId = foundOrder.orderId || foundOrder._id;

    // 模拟支付流程
    wx.showModal({
      title: '支付提示',
      content: '确认支付该订单？',
      success: (res) => {
        if (res.confirm) {
          // 更新订单状态
          this.updateOrderStatus(validOrderId, 'paid');

          wx.showToast({
            title: '支付成功',
            icon: 'success'
          });
        }
      }
    });
  },

  /**
   * 确认收货
   */
  confirmReceived(e) {
    // 微信小程序事件对象不支持stopPropagation方法
    // 使用catchtap已经足够阻止冒泡

    // 打印完整事件对象，用于调试
    console.log('确认收货事件对象:', e);

    const orderId = e.currentTarget.dataset.id;
    console.log('确认收货, orderId:', orderId);

    // 在数据中查找匹配的订单
    const orderIndex = this.data.filteredOrders.findIndex(order =>
      order.orderId === orderId || order._id === orderId
    );

    console.log('找到订单索引:', orderIndex);

    if (orderIndex === -1) {
      // 如果在过滤后的订单中找不到，再从所有订单中查找
      const allOrderIndex = this.data.allOrders.findIndex(order =>
        order.orderId === orderId || order._id === orderId
      );

      console.log('在所有订单中找到索引:', allOrderIndex);

      if (allOrderIndex === -1) {
        console.error('无效的订单ID, 在数据中未找到匹配订单:', orderId);
        wx.showToast({
          title: '订单信息有误',
          icon: 'none'
        });
        return;
      } else {
        // 使用找到的订单的ID
        const foundOrder = this.data.allOrders[allOrderIndex];
        const validOrderId = foundOrder.orderId || foundOrder._id;
        console.log('使用找到的有效订单ID:', validOrderId);

        this.showConfirmDialog(validOrderId);
      }
    } else {
      const foundOrder = this.data.filteredOrders[orderIndex];
      const validOrderId = foundOrder.orderId || foundOrder._id;
      console.log('使用找到的有效订单ID:', validOrderId);

      this.showConfirmDialog(validOrderId);
    }
  },

  /**
   * 显示确认对话框
   */
  showConfirmDialog(orderId) {
    wx.showModal({
      title: '确认提示',
      content: '确认已收到商品？',
      success: (res) => {
        if (res.confirm) {
          // 更新订单状态
          this.updateOrderStatus(orderId, 'completed');
        }
      }
    });
  },

  /**
   * 再来一单
   */
  reorder(e) {
    // 微信小程序事件对象不支持stopPropagation方法
    // 使用catchtap已经足够阻止冒泡

    const orderId = e.currentTarget.dataset.id;
    console.log('再来一单, orderId:', orderId);

    // 在数据中查找匹配的订单
    const orderIndex = this.data.filteredOrders.findIndex(order =>
      order.orderId === orderId || order._id === orderId
    );

    if (orderIndex === -1) {
      console.error('无效的订单ID');
      wx.showToast({
        title: '订单信息有误',
        icon: 'none'
      });
      return;
    }

    const orderItems = this.data.filteredOrders[orderIndex].orderItems;

    // 将商品添加到购物车
    wx.setStorageSync('cartList', orderItems);

    wx.showToast({
      title: '已添加到购物车',
      icon: 'success',
      success: () => {
        // 跳转到购物车页面
        setTimeout(() => {
          wx.switchTab({
            url: '/pages/cart/cart'
          });
        }, 1500);
      }
    });
  },

  /**
   * 联系店家
   */
  callShop(e) {
    // 微信小程序事件对象不支持stopPropagation方法
    // 使用catchtap已经足够阻止冒泡

    const phone = e.currentTarget.dataset.phone;

    wx.makePhoneCall({
      phoneNumber: phone,
      fail: () => {
        // 拨打电话失败或用户取消
        wx.showToast({
          title: '拨打电话失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 更新订单状态
   */
  updateOrderStatus(orderId, status) {
    console.log('开始更新订单状态:', orderId, status);

    wx.showLoading({
      title: '更新中',
      mask: true
    });

    // 调用云函数更新订单状态
    wx.cloud.callFunction({
      name: 'updateOrder',
      data: {
        orderId: orderId,
        status: status
      }
    })
      .then(res => {
        wx.hideLoading();
        console.log('更新订单状态结果:', res);

        if (res.result && res.result.success) {
          // 显示成功提示
          wx.showToast({
            title: status === 'completed' ? '确认成功' : '更新成功',
            icon: 'success',
            duration: 1500
          });

          // 延迟后重新加载订单列表
          setTimeout(() => {
            this.loadOrders();
          }, 1500);
        } else {
          const errorMsg = res.result ? res.result.message : '未知错误';
          console.error('更新订单状态失败:', errorMsg);

          wx.showModal({
            title: '更新失败',
            content: errorMsg || '服务器处理异常，请稍后再试',
            showCancel: false
          });
        }
      })
      .catch(err => {
        console.error('调用云函数失败:', err);
        wx.hideLoading();

        wx.showModal({
          title: '网络错误',
          content: '请检查网络连接后重试',
          showCancel: false
        });
      });
  },

  /**
   * 加载更多订单
   */
  loadMoreOrders() {
    if (this.data.isLoading || !this.data.hasMoreOrders) {
      return;
    }

    this.setData({
      isLoading: true,
      currentPage: this.data.currentPage + 1
    });

    // 模拟加载更多
    setTimeout(() => {
      this.setData({
        isLoading: false,
        hasMoreOrders: false // 假设没有更多数据了
      });
    }, 1000);
  },

  /**
   * 跳转到菜单页
   */
  goToMenu() {
    wx.switchTab({
      url: '/pages/menu/menu'
    });
  },

  /**
   * 阻止事件冒泡
   */
  stopEvent(e) {
    // 阻止事件冒泡
    return;
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次显示页面时重新加载订单，以获取最新数据
    this.loadOrders();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    // 下拉刷新
    this.loadOrders();

    // 停止下拉刷新动画
    wx.stopPullDownRefresh();
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    // 分享页面
    return {
      title: '我的订单',
      path: '/pages/orderList/orderList'
    };
  }
})